#ifndef __SERVER_HPP__
#define __SERVER_HPP__

#include <iostream>
#include <ctime>
#include <cassert>
#include <cstdlib>
#include <cstring>
#include <cstdint>
#include <string>
#include <vector>
#include <functional>
#include <unordered_map>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <any>
#include <typeinfo>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <sys/timerfd.h>

// #define INF 0
// #define DEBUG 1
// #define ERROR 2
// #define DEFAULT_LOG_LEVEL INF

// #define LOG(level, format, ...)                                                      \
//     do                                                                               \
//     {                                                                                \
//         if (DEFAULT_LOG_LEVEL > level)                                               \
//             break;                                                                   \
//         time_t t = time(nullptr);                                                    \
//         struct tm *lt = localtime(&t);                                               \
//         char tmp[32] = {0};                                                          \
//         strftime(tmp, 31, "%H:%M:%S", lt);                                           \
//         fprintf(stderr, "[%p %s %s:%d] " format "\n",                                \
//                 std::this_thread::get_id(), tmp, __FILE__, __LINE__, ##__VA_ARGS__); \
//     } while (0)

// #define ILOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
// #define DLOG(format, ...) LOG(DEBUG, format, ##__VA_ARGS__)
// #define ELOG(format, ...) LOG(ERROR, format, ##__VA_ARGS__)

enum
{
    NORMAL,
    DEBUG,
    WARNING,
    ERROR,
    FATAL
};

// 将日志等级转换为字符串
const char *level_to_string(int level)
{
    switch (level)
    {
    case NORMAL:
        return "NORMAL";
    case DEBUG:
        return "DEBUG";
    case WARNING:
        return "WARNING";
    case ERROR:
        return "ERROR";
    case FATAL:
        return "FATAL";
    default:
        return "";
    }
}

#define LogMessage(level, format, ...)                                                                                                                    \
    do                                                                                                                                                    \
    {                                                                                                                                                     \
        const char *level_str = level_to_string(level); /*日志等级*/                                                                                  \
        time_t ts = time(nullptr);                      /*时间戳*/                                                                                     \
        struct tm *lt = localtime(&ts);                 /*格式化时间*/                                                                               \
        char tmp[32] = {0};                                                                                                                               \
        strftime(tmp, sizeof(tmp) - 1, "%Y-%m-%d %H:%M:%S", lt);                                            /*格式化时间到字符串*/               \
        fprintf(stdout, "[%s][%s][%s:%d] " format "\n", level_str, tmp, __FILE__, __LINE__, ##__VA_ARGS__); /*##解除必须传递可变参数的限制*/ \
    } while (0)

#define BUFFER_DEFAULT_SIZE 1024
class Buffer
{
private:
    std::vector<char> _buffer; // 使用vector进行内存空间管理
    uint64_t _reader_idx;      // 读偏移
    uint64_t _writer_idx;      // 写偏移

public:
    Buffer() : _reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}
    ~Buffer() {}

public:
    // 获取起始地址
    char *Begin() { return &*_buffer.begin(); }
    // 获取当前写入起始位置 _buffer的空间起始地址加上写偏移量
    char *WritePosition() { return Begin() + _writer_idx; }
    // 获取当前读物起始位置
    char *ReadPosition() { return Begin() + _reader_idx; }
    // 获取前沿空闲空间大小(缓冲区末尾)--写偏移之后的空闲空间，总体空间大小减去写偏移
    uint64_t TailIdleSize() { return _buffer.size() - _writer_idx; }
    // 获取后沿空闲空间大小(缓冲区起始)--读偏移之前的空闲空间--读偏移之前的空闲空间
    uint64_t HeadIdleSize() { return _reader_idx; }
    // 获取可读数据大小 写偏移-读偏移
    uint64_t ReadAbleSize() { return _writer_idx - _reader_idx; }

    // 将读偏移向后移动
    void MoveReadOffset(const uint64_t &len)
    {
        if (len == 0)
            return;
        // 读偏移向后移动的大小,必须小于可读数据大小
        assert(len <= ReadAbleSize());
        _reader_idx += len;
    }

    // 将写偏移向后移动
    void MoveWriteOffset(const uint64_t &len)
    {
        if (len == 0)
            return;
        // 写偏移向后移动的大小,必须小于后边的空闲空间大小
        assert(len <= TailIdleSize());
        _writer_idx += len;
    }

    // 确保可写空间足够(整体空间足够了就一定数据,否则就扩容)
    void EnsureWriteSpace(const uint64_t &len)
    {
        // 1.如果末尾空闲空间大小足够,直接返回
        if (len <= TailIdleSize())
        {
            return;
        }
        // 2.末尾空闲空间不够,则判断加上起始空闲空间大小是否足够，足够就将数据移动到起始位置
        else if (len <= TailIdleSize() + HeadIdleSize())
        {
            // 将数据移动到起始位置
            uint64_t readablesize = ReadAbleSize(); // 把当前数据大小先保存起来

            // 将数据拷贝到起始位置
            // std::copy(ReadPosition(),WritePosition(),Begin());
            std::copy(ReadPosition(), ReadPosition() + readablesize, Begin());

            _reader_idx = 0;            // 将读偏移归0
            _writer_idx = readablesize; // 将写位置置为可读数据大小
        }
        // 3.总体空间不够,则需要扩容,不移动数据,直接给写偏移之后扩容足够空间即可
        else
        {
            _buffer.resize(_writer_idx + len);
        }
    }

    // 写入数据
    void Write(const void *data, const uint64_t &len)
    {
        // 1.保证有足够的空间 2.将数据拷贝进去
        if (len == 0)
            return;
        EnsureWriteSpace(len);
        const char *d = (const char *)data;
        std::copy(d, d + len, WritePosition());
    }

    // 写入数据并且写偏移向后移动
    void WriteAndPush(const void *data, const uint64_t &len)
    {
        Write(data, len);
        MoveWriteOffset(len);
    }

    // 写入字符串
    void WriteString(std::string &data)
    {
        // return Write(&data[0], data.size());
        return Write(data.c_str(), data.size());
    }

    // 写入字符串并且写偏移向后移动
    void WriteStringAndPush(std::string &data)
    {
        WriteString(data);
        MoveWriteOffset(data.size());
    }

    // 写入一个Buffer对象
    void WriteBuffer(Buffer &data)
    {
        return Write(data.ReadPosition(), data.ReadAbleSize());
    }

    void WriteBufferAndPush(Buffer &data)
    {
        WriteBuffer(data);
        MoveWriteOffset(data.ReadAbleSize());
    }

    // 读取数据
    void Read(void *buffer, const uint64_t &len)
    {
        // 要求要获取的数据大小必须小于可读数据大小
        assert(len <= ReadAbleSize());
        std::copy(ReadPosition(), ReadPosition() + len, (char *)buffer);
    }

    // 读取数据并读偏移向后移动
    void ReadAndPop(void *buffer, const uint64_t &len)
    {
        Read(buffer, len);
        MoveReadOffset(len);
    }

    // 读取数据放入一个字符串中
    std::string ReadAsString(const uint64_t &len)
    {
        // 要求要获取的数据大小必须小于可读数据大小
        assert(len <= ReadAbleSize());
        std::string str;
        str.resize(len);
        Read(&str[0], len);
        return str;
    }

    std::string ReadAsStringAndPop(const uint64_t &len)
    {
        assert(len <= ReadAbleSize());
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }

    // 找到换行字符
    char *FindCRLF()
    {
        char *res = (char *)memchr(ReadPosition(), '\n', ReadAbleSize());
        return res;
    }

    // 获取一行数据
    std::string GetOneLine()
    {
        char *pos = FindCRLF();
        if (pos == nullptr)
            return "";

        // +1是为了将换行字符也取出来
        return ReadAsString(pos - ReadPosition() + 1);
    }

    std::string GetOneLineAndPop()
    {
        std::string str = GetOneLine();
        MoveReadOffset(str.size());
        return str;
    }

    // 清空缓冲区
    void Clear()
    {
        _reader_idx = 0;
        _writer_idx = 0;
    }
};

#define MAX_LISTEN 1024
class Socket
{
private:
    int _sockfd;

public:
    Socket() : _sockfd(-1) {}
    Socket(int fd) : _sockfd(fd) {}
    ~Socket() { Close(); }
    int Fd() { return _sockfd; }

public:
    // 创建套接字
    bool Create()
    {
        // int socket(int domain,int type,int protocol)
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0)
        {
            LogMessage(FATAL, "socket create failed");
            return false;
        }
        return true;
    }

    // 绑定地址信息
    bool Bind(const std::string &ip, const uint16_t &port)
    {
        struct sockaddr_in local;
        memset(&local, 0, sizeof local);

        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        local.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(local);

        // int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
        int ret = bind(_sockfd, (struct sockaddr *)&local, len);
        if (ret < 0)
        {
            LogMessage(FATAL, "socket bind failed");
            return false;
        }
        return true;
    }

    // 开始监听
    bool Listen(int backlog = MAX_LISTEN)
    {
        // int listen(int sockfd, int backlog);
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            LogMessage(FATAL, "socket listen failed");
            return false;
        }
        return true;
    }

    // 向服务器发起连接
    bool Connect(const std::string &ip, const uint16_t &port)
    {
        struct sockaddr_in server;
        memset(&server, 0, sizeof server);

        server.sin_family = AF_INET;
        server.sin_port = htons(port);
        server.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(server);

        // int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
        int ret = connect(_sockfd, (struct sockaddr *)&server, len);
        if (ret < 0)
        {
            LogMessage(FATAL, "socket connect failed");
            return false;
        }
        return true;
    }

    // 获取新连接
    int Accept()
    {
        // int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
        int newfd = accept(_sockfd, nullptr, nullptr);
        if (newfd < 0)
        {
            LogMessage(FATAL, "connect newfd failed");
            return -1;
        }
        return newfd;
    }

    // 接收数据
    ssize_t Recv(void *buf, size_t len, int flags = 0)
    {
        // ssize_t recv(int sockfd, void *buf, size_t len, int flags);
        ssize_t ret = recv(_sockfd, buf, len, flags);
        if (ret <= 0)
        {
            // EAGAIN表示当前socket的接收缓冲区中没有数据了,在非阻塞的情况下才会有这个错误
            // EINTR 表示当前socket的阻塞等待,被信号打断了
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0;
            }
            LogMessage(FATAL, "recv message failed");
            return -1;
        }
        // 返回实际接收到的长度
        return ret;
    }

    // 非阻塞接收数据
    ssize_t NonBlockRecv(void *buf, size_t len)
    {
        // MSG_DONTWAIT表示当接收为非阻塞
        return Recv(buf, len, MSG_DONTWAIT);
    }

    // 发送数据
    ssize_t Send(const void *buf, size_t len, int flags = 0)
    {
        // ssize_t send(int sockfd, const void *buf, size_t len, int flags);
        ssize_t ret = send(_sockfd, buf, len, flags);
        if (ret < 0)
        {
            if (errno == EINTR || errno == EAGAIN)
            {
                return 0;
            }
            LogMessage(FATAL, "send message failed");
            return -1;
        }
        // 返回实际发送的长度
        return ret;
    }

    // 非阻塞发送数据
    ssize_t NonBlockSend(const void *buf, size_t len)
    {
        if (len == 0)
            return 0;
        // MSG_DONTWAIT表示当前发送为非阻塞
        return Send(buf, len, MSG_DONTWAIT);
    }

    // 关闭套接字
    void Close()
    {
        if (_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }

    // 创建一个服务端连接
    bool CreateServer(const uint16_t &port, const std::string &ip = "0.0.0.0", bool block_flag = false)
    {
        // 1.创建套接字,2.设置非阻塞3.绑定地址,4.开始监听,5.启动地址重用
        if (Create() == false)
            return false;
        if (block_flag)
            NonBlock();
        if (Bind(ip, port) == false)
            return false;
        if (Listen() == false)
            return false;
        ReuseAddress();
        return true;
    }

    // 创建一个客户端连接
    bool CreateClient(const uint16_t &port, const std::string &ip)
    {
        // 1.创建套接字,2,连接服务器
        if (Create() == false)
            return false;
        if (Connect(ip, port) == false)
            return false;
        return true;
    }

    // 设置套接字选项 --开启地址端口重用
    void ReuseAddress()
    {
        // int setsockopt(int sockfd, int level, int optname,const void *optval, socklen_t optlen);
        int opt = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&opt, sizeof opt);
        opt = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void *)&opt, sizeof opt);
        // int val = 1;
        // setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, (void*)&val, sizeof(val));
    }

    // 设置套接字属性--设置为非阻塞
    void NonBlock()
    {
        // int fcntl(int fd, int cmd, ... /* arg */ );
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }
};

class Poller;
class EventLoop;
class Channel
{
private:
    int _fd; // 文件描述符
    EventLoop *_loop;
    uint32_t _events;  // 当前需要监控的事件
    uint32_t _revents; // 当前连接触发的事件
    using EventCallback = std::function<void()>;
    EventCallback _read_callback;  // 可读事件被触发的回调函数
    EventCallback _write_callback; // 可写事件被触发的回调函数
    EventCallback _error_callback; // 错误事件被触发的回调函数
    EventCallback _close_callback; // 连接断开事件被触发的回调函数
    EventCallback _event_callback; // 任意事件被触发的回调函数
public:
    Channel(EventLoop *loop, int fd) : _fd(fd), _events(0), _revents(0), _loop(loop) {}

    // 获取文件描述符
    int Fd() { return _fd; }
    // 获取想要监控的事件
    uint32_t Events() { return _events; }
    // 设置实际就绪事件
    void SetRevents(const uint32_t &revents) { _revents = revents; }
    // 设置回调函数
    void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
    void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
    void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
    void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
    void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }

    // 当前是否监控了可读
    bool ReadAble() { return (_events & EPOLLIN); }
    // 当前是否监控了可写
    bool WriteAble() { return (_events & EPOLLOUT); }
    // 启动可读事件
    void EnableRead()
    {
        _events |= EPOLLIN;
        Update();
    }
    // 启动可写事件
    void EnableWrite()
    {
        _events |= EPOLLOUT;
        Update();
    }
    // 关闭读事件监控
    void DisableRead()
    {
        _events &= (~EPOLLIN);
        Update();
    }
    // 关闭写事件监控
    void DisableWrite()
    {
        _events &= (~EPOLLOUT);
        Update();
    }
    // 关闭所有事件监控
    void DisableAll()
    {
        _events = 0;
        Update();
    }

    // 移除监控
    void Remove();
    // 添加监控
    void Update();

    // 事件处理，一旦发生了事件，就调用这个函数，自己触发 什么事件如何处理自己决定
    void HandleEvent()
    {
        // 可读事件就绪
        // EPOLLIN读事件就绪/EPOLLRDHUP客户端连接半关闭(需要读取缓冲区中可能的剩余数据)/EPOLLPRI存在优先带外数据
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            if (_read_callback)
            {
                _read_callback();
            }
        }
        // 可写事件就绪
        if (_revents & EPOLLOUT)
        {
            if (_write_callback)
                _write_callback();
        }
        // 错误事件 //一旦出错，就会释放连接，因此要放到前边调用任意回调
        else if (_revents & EPOLLERR)
        {
            if (_error_callback)
                _error_callback();
        }
        // 连接断开 //一旦出错，就会释放连接，因此要放到前边调用任意回调
        else if (_revents & EPOLLHUP)
        {
            if (_close_callback)
                _close_callback();
        }
        if (_event_callback)
            _event_callback();
    }
};

#define MAX_EPOLLEVENT 1024
class Poller
{
private:
    int _epfd;
    struct epoll_event _evs[MAX_EPOLLEVENT];
    std::unordered_map<int, Channel *> _channels;

private:
    // 对epoll的直接操作
    void Update(Channel *channel, int op)
    {
        // int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
        struct epoll_event ev;
        ev.events = channel->Events();
        ev.data.fd = channel->Fd();

        int ret = epoll_ctl(_epfd, op, channel->Fd(), &ev);
        if (ret < 0)
        {
            LogMessage(FATAL, "epollctl failed");
        }
        return;
    }

    // 判断一个channel是否已经添加了事件监控
    bool HasChannel(Channel *Channel)
    {
        auto it = _channels.find(Channel->Fd());
        return it != _channels.end();

        // if(it == _channels.end()) return false;
        // return true;
    }

public:
    Poller()
    {
        // int epoll_create(int size);
        _epfd = epoll_create(MAX_EPOLLEVENT);
        if (_epfd < 0)
        {
            LogMessage(FATAL, "epoll create failed");
            abort();
        }
    }

    // 添加或修改监控事件
    void UpdateEvent(Channel *channel)
    {
        bool ret = HasChannel(channel);
        // 不存在则添加
        if (ret == false)
        {
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }
        // 存在则修改
        return Update(channel, EPOLL_CTL_MOD);
    }

    // 移除监控
    void RemoveEvent(Channel *channel)
    {
        // bool ret = HasChannel(channel);
        // if(ret != false)
        // {
        //     _channels.erase(channel->Fd());
        //     return Update(channel,EPOLL_CTL_DEL);
        // }

        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())
        {
            _channels.erase(it);
            return Update(channel, EPOLL_CTL_DEL);
        }
    }

    // 开始监控,返回活跃连接
    void Poll(std::vector<Channel *> *actives)
    {
        // int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENT, -1);
        if (nfds < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            LogMessage(FATAL, "epoll wait failed");
            abort();
        }

        for (int i = 0; i < nfds; i++)
        {
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());

            // 设置实际的就绪事件
            it->second->SetRevents(_evs[i].events);
            actives->push_back(it->second);
        }
        return;
    }
};

// 定时器任务
// 定时器任务的回调函数,即超时时执行的任务
using TaskFunc = std::function<void()>;
// 定时器对象销毁的回调函数
using ReleaseFunc = std::function<void()>;
class TimerTask
{
private:
    uint64_t _id;         // 定时器任务对象id
    uint32_t _timeout;    // 超时定时任务的超时时间
    bool _canceled;       // 超时任务：false表示没有被取消,true表示被取消了
    TaskFunc _task_cb;    // 定时器对象要执行的定时任务
    ReleaseFunc _release; // 用于删除TimerWheel中保存的定时器对象信息
public:
    TimerTask(const uint64_t &id, const uint32_t &delay, const TaskFunc &cb)
        : _id(id), _timeout(delay), _task_cb(cb), _canceled(false) {}
    ~TimerTask()
    {
        if (_canceled == false)
            _task_cb();
        _release();
    }

    void Canceled() { _canceled = true; }
    uint32_t DelayTime() { return _timeout; }
    void SetRelease(const ReleaseFunc &cb) { _release = cb; }
};

class EventLoop;
// 时间轮
// 管理定时器任务的shared_ptr
using PtrTask = std::shared_ptr<TimerTask>;
// 管理定时器任务的weak_ptr
using WeakTask = std::weak_ptr<TimerTask>;
class TimerWheel
{
private:
    int _tick;     // 当前的秒针,走到哪里释放哪里,就相当于执行哪里的任务
    int _capacity; // 表盘的最大数量,即最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel;
    std::unordered_map<uint64_t, WeakTask> _timers;

    EventLoop *_loop;
    int _timerfd; // 定时器描述符--可读事件回调就是读取定时器,并执行定时任务
    std::unique_ptr<Channel> _timer_channel;

private:
    /*SetRelease回调函数 -- 从unordered_map中将定时任务信息移除*/
    void RemoveTimer(const uint64_t &id)
    {
        auto it = _timers.find(id);
        if (it != _timers.end())
        {
            _timers.erase(it);
        }
    }

    // 创建定时器描述符
    static int CreateTimerfd()
    {
        // 创建一个定时器
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            LogMessage(FATAL, "create timerfd failed");
            abort();
        }

        // 设置超时时间
        struct itimerspec ims;
        // 第一次超时时间为1s后
        ims.it_value.tv_sec = 1;
        ims.it_value.tv_nsec = 0;
        // 第一次超时后，每次超时的间隔时
        ims.it_interval.tv_sec = 1;
        ims.it_interval.tv_nsec = 0;

        // 启动定时器
        int n = timerfd_settime(timerfd, 0, &ims, nullptr);
        if (n < 0)
        {
            LogMessage(FATAL, "timerfd settime failed");
            abort();
        }
        return timerfd;
    }

    // 读取定时器描述符的数据
    int ReadTimerfd()
    {
        uint64_t times;
        // 有可能因为其他描述符的事件处理花费事件比较长，然后在处理定时器描述符事件的时候，
        // 有可能就已经超时了很多次
        // read读取到的数据times就是从上一次read之后超时的次数
        ssize_t ret = read(_timerfd, &times, 8);
        if (ret < 0)
        {
            LogMessage(FATAL, "read timerfd failed");
            abort();
        }
        return times;
    }

    // 这个函数应该每秒钟被执行一次,相当于秒针向后走了一步
    void RunTimerTask()
    {
        _tick = (_tick + 1) % _capacity;
        // 清空指定位置的数组,就会把数组中保存的所有管理定时器对象的shared_ptr释放掉
        _wheel[_tick].clear();
    }

    // 定时器读事件的回调函数
    void OnTime()
    {
        // 根据实际超时的次数，执行对应的超时任务
        int times = ReadTimerfd();
        for (int i = 0; i < times; i++)
        {
            RunTimerTask();
        }
    }

    // 添加定时任务
    void TimerAddInLoop(const uint64_t &id, const uint32_t &delay, const TaskFunc &cb)
    {
        PtrTask ptr(new TimerTask(id, delay, cb));
        ptr->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        int pos = (_tick + delay) % _capacity;

        // 将shared_ptr管理的对象加入到时间轮中
        _wheel[pos].push_back(ptr);
        // 将shared_ptr管理的对象的weak_ptr加入到哈希表中
        _timers[id] = WeakTask(ptr);
    }

    // 刷新/延迟定时时间
    void TimerRefreshInLoop(const uint64_t &id)
    {
        // 通过保存的定时器的weak_ptr构造一个shared_ptr出来,添加到轮子中
        auto it = _timers.find(id);
        // 没找着定时任务，没法刷新，没法延迟
        if (it == _timers.end())
        {
            return;
        }
        // lock获取weak_ptr管理的对象对应的shared_ptr
        PtrTask ptr = it->second.lock();
        int delay = ptr->DelayTime();
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(ptr);
    }

    // 取消定时任务
    void TimerCancelInLoop(const uint64_t &id)
    {
        auto it = _timers.find(id);
        // 没有找到定时任务就没法刷新和延迟,直接退出
        if (it == _timers.end())
            return;
        PtrTask ptr = it->second.lock();
        if (ptr)
            ptr->Canceled();
    }

public:
    TimerWheel(EventLoop *loop)
        : _tick(0), _capacity(60), _wheel(_capacity),
          _loop(loop), _timerfd(CreateTimerfd()),
          _timer_channel(new Channel(_loop, _timerfd))
    {
        _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
        _timer_channel->EnableRead(); // 启动读事件
    }

    // 定时器有个成员_timers成员,定时器信息的操作有可能在多个线程中进行,因此要考虑线程安全
    // 如果不想加锁,那就把对定时器的所有操作,都放到一个线程中执行
    // 添加定时任务
    /*为了保证添加/刷新/取消定时器任务的线程安全，我们需要在EventLoop对应的线程中去执行它们*/
    // 同时，这里也和Channel::Remove Channel::Update函数一样，我们使用了EventLoop中的成员函数
    // 所以，下面只给出声明，函数的具体实现需要放到EventLoop类下面
    void TimerAdd(const uint64_t &id, const uint32_t &delay, const TaskFunc &cb);
    // 刷新/延迟定时时间
    void TimerRefresh(const uint64_t &id);
    // 取消定时任务
    void TimerCancel(const uint64_t &id);

    // 由于HasTimer的返回值是bool类型，所以无法像Timeradd等函数一样将其放入到EventLoop的任务队列中去执行
    // 存在线程安全问题,不能被外界使用者调用,只能在模块内,在对应的EventLoop线程内调用
    bool HasTimer(const uint64_t &id)
    {
        auto it = _timers.find(id);
        // 没有找到定时任务就没法刷新和延迟,直接退出
        if (it == _timers.end())
            return false;
        return true;
    }
};

// 事件循环
class EventLoop
{
private:
    using Functor = std::function<void()>;
    std::thread::id _thread_id; // 线程ID
    int _event_fd;              // eventfd唤醒IO事件监控有可能导致的阻塞
    std::unique_ptr<Channel> _event_channel;
    Poller _poller;              // 进行描述符的事件监控
    std::vector<Functor> _tasks; // 任务池
    std::mutex _mutex;           // 实现任务池操作的线程安全
    TimerWheel _timer_wheel;     // 定时器模块
private:
    // 执行任务池中的所有任务
    void RunAllTask()
    {
        std::vector<Functor> functor;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _tasks.swap(functor);
        }

        for (auto &func : functor)
        {
            func();
        }
        return;
    }

    // 创建一个eventfd对象,实现事件通知
    static int CreateEventFd()
    {
        // int eventfd(unsigned int initval, int flags);
        // EFD_CLOEXEC--禁止进程复制
        // EFD_NONBLCK--启动非阻塞属性
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            LogMessage(FATAL, "eventfd create failed");
            abort();
        }
        return efd;
    }

    // 读取eventfd中的数据,来完成清0-线程接收通知
    void ReadEventFd()
    {
        uint64_t res = 0;
        int ret = read(_event_fd, &res, sizeof(res));
        if (ret <= 0)
        {
            // EINTR----被信号打断  EAGAIN -- 表示无数据可读
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            LogMessage(FATAL, "read eventfd failed");
            abort();
        }
        return;
    }

    // 向eventfd写入数据，实现线程的通知
    void WeakUpEventFd()
    {
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if (ret < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            LogMessage(FATAL, "write eventfd failed");
            abort();
        }
        return;
    }

public:
    EventLoop() : _thread_id(std::this_thread::get_id()),
                  _event_fd(CreateEventFd()),
                  _event_channel(new Channel(this, _event_fd)),
                  _timer_wheel(this)
    {
        // 给eventfd 添加可读事件回调函数,读取eventfd事件通知次数
        _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventFd, this));
        // 启动eventfd的读事件监控
        _event_channel->EnableRead();
    }

    // 三步走---事件监控--》就绪事件处理--》执行任务
    void Start()
    {
        for (;;)
        {
            // 1.事件监控
            std::vector<Channel *> actives;
            _poller.Poll(&actives);

            // 2.就绪事件处理
            for (auto &channel : actives)
            {
                channel->HandleEvent();
            }
            // 3.执行任务
            RunAllTask();
        }
    }

    // 用于判断当前线程是否是EventLoop对应的线程
    bool IsInLoop()
    {
        return _thread_id == std::this_thread::get_id();
    }

    void AssertInLoop()
    {
        assert(_thread_id == std::this_thread::get_id());
    }

    // 判断将要执行的任务是否处于当前线程中
    void RunInLoop(const Functor &cb)
    {
        if (IsInLoop())
        {
            return cb();
        }
        return QueueInLoop(cb);
    }

    // 将操作压入任务池
    void QueueInLoop(const Functor &cb)
    {
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _tasks.push_back(cb);
        }
        // 唤醒有可能因为没有事件就绪,而导致的epoll阻塞
        // 其实就是给eventfd写入一个数据,eventfd就会触发可读事件
        WeakUpEventFd();
    }

    // 添加/修改描述符的事件监控
    void UpdateEvent(Channel *channel)
    {
        return _poller.UpdateEvent(channel);
    }

    // 移除描述符的事件监控
    void RemoveEvent(Channel *channel)
    {
        return _poller.RemoveEvent(channel);
    }

    // 添加定时任务
    void TimerAdd(const uint64_t &id, const uint32_t &delay, const TaskFunc &cb)
    {
        return _timer_wheel.TimerAdd(id, delay, cb);
    }

    // 刷新定时任务
    void TimerRefresh(const uint64_t &id)
    {
        return _timer_wheel.TimerRefresh(id);
    }

    // 取消定时任务
    void TimerCancel(const uint64_t &id)
    {
        return _timer_wheel.TimerCancel(id);
    }

    bool HasTimer(const uint64_t &id)
    {
        return _timer_wheel.HasTimer(id);
    }
};

class LoopThread
{
private:
    /*用于实现_loop获取的同步关系，避免线程创建了，但是_loop还没有实例化之前去获取_loop*/
    std::mutex _mutex;             // 互斥锁
    std::condition_variable _cond; // 条件变量
    EventLoop *_loop;              // EventLoop指针变量，这个对象需要在线程内实例化
    std::thread _thread;           // EventLoop对应的线程

private:
    /*实例化 EventLoop 对象，唤醒_cond上有可能阻塞的线程，并且开始运行EventLoop模块的功能*/
    void ThreadEntry()
    {
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _loop = &loop;
            _cond.notify_all();
        }
        loop.Start();
    }

public:
    /*创建线程，设定线程入口函数*/
    LoopThread() : _thread(std::thread(&LoopThread::ThreadEntry, this)), _loop(nullptr) {}
    /*返回当前线程关联的EventLoop对象指针*/
    EventLoop *GetEventLoop()
    {
        EventLoop *loop = nullptr;
        {
            std::unique_lock<std::mutex> lock(_mutex); // 加锁
            _cond.wait(lock, [&]()
                       { return _loop != nullptr; }); //_loop为nullptr就一直阻塞
            loop = _loop;
        }
        return loop;
    }
};

class LoopThreadPool
{
private:
    int _thread_count;                  // 从属线程的数量
    int _next_idx;                      // RR轮转的下标
    EventLoop *_base_loop;              // 主EventLoop,运行在主线程,从属线程数量为0,则所有的操作都在baseloop中运行
    std::vector<LoopThread *> _threads; // 保存所有的LoopThread对象
    std::vector<EventLoop *> _loops;    // 从属线程数量大于0则从_loops中进行线程EventLoop分配

public:
    LoopThreadPool(EventLoop *baesloop)
        : _thread_count(0), _next_idx(0), _base_loop(baesloop) {}
    void SetThreadCount(const int &count) { _thread_count = count; }
    void Create()
    {
        if (_thread_count > 0)
        {
            _threads.resize(_thread_count);
            _loops.resize(_thread_count);
            for (int i = 0; i < _thread_count; i++)
            {
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->GetEventLoop();
            }
        }
    }

    EventLoop *GetNextLoop()
    {
        if (_thread_count == 0)
        {
            return _base_loop;
        }
        _next_idx = (_next_idx + 1) % _thread_count;
        return _loops[_next_idx];
    }
};

class Any
{
private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info &type() = 0;
        virtual holder *clone() = 0;
    };
    template <class T>
    class placeholder : public holder
    {
    public:
        placeholder(const T &val) : _val(val) {}
        // 获取子类对象保存的数据类型
        virtual const std::type_info &type() { return typeid(T); }
        // 针对当前的对象自身，克隆出一个新的子类对象
        virtual holder *clone() { return new placeholder(_val); }

    public:
        T _val;
    };

    holder *_content;

public:
    Any() : _content(nullptr) {}
    template <class T>
    Any(const T &val) : _content(new placeholder<T>(val)) {}
    Any(const Any &other) : _content(other._content ? other._content->clone() : nullptr) {}
    ~Any() { delete _content; }

    Any &swap(Any &other)
    {
        std::swap(_content, other._content);
        return *this;
    }

    // 返回子类对象保存的数据的指针
    template <class T>
    T *get()
    {
        // 想要获取的数据类型，必须和保存的数据类型一致
        assert(typeid(T) == _content->type());
        return &((placeholder<T> *)_content)->_val;
    }
    // 赋值运算符的重载函数
    template <class T>
    Any &operator=(const T &val)
    {
        // 为val构造一个临时的通用容器，然后与当前容器自身进行指针交换，临时对象释放的时候，原先保存的数据也就被释放
        Any(val).swap(*this);
        return *this;
    }
    Any &operator=(const Any &other)
    {
        Any(other).swap(*this);
        return *this;
    }
};

class Connection;
// DISCONNECTED -- 连接关闭状态   CONNECTING -- 连接建立成功
// CONNECTED -- 连接建立完成,各种设置已完成,可以通信的状态
// DISCONNECTING -- 待关闭的状态
typedef enum
{
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    DISCONNECTING
} ConnStatu;

using PtrConnection = std::shared_ptr<Connection>;
class Connection : public std::enable_shared_from_this<Connection>
{
private:
    uint64_t _conn_id; // 连接的唯一ID
    // uint64_t _timer_id;            // 定时器ID,必须是唯一的,这块为了简化操作使用conn_id作为定时器ID
    int _sockfd;                   // 连接关联的文件描述符
    bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志,默认为false
    EventLoop *_loop;              // 连接所关联的一个EventLoop
    ConnStatu _statu;              // 连接的状态
    Socket _socket;                // 套接字操作管理
    Channel _channel;              // 连接的事件管理
    Buffer _in_buffer;             // 输入缓冲区--存放从socket中读到的数据
    Buffer _out_buffer;            // 输出缓冲区--存放要发送给对端的数据
    Any _context;                  // 请求的接收处理的上下文

    /*这四个回调函数，是让服务器模块来设置的（其实服务器模块的处理回调也是组件使用者设置的）*/
    /*换句话说，这几个回调都是组件使用者使用的*/
    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
    /*组件内的连接关闭回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭*/
    /*就应该从管理的地方移除掉自己的信息*/
    ClosedCallback _server_closed_callback;

private:
    // 五个Channel的事件回调函数
    // 描述符可读事件触发后的回调函数
    void HandleRead()
    {
        // 1.接收socket的数据,放到缓冲区
        char buffer[65536];
        ssize_t ret = _socket.NonBlockRecv(buffer, 65535);
        if (ret < 0)
        {
            // 出错了，不能直接关闭连接
            return ShutDownInLoop();
        }
        // else if (ret == 0)
        // {
        //     // 这里等于0表示的是没有读到数据,而并不是连接断开了,连接断开返回的是-1
        //     return;
        // }

        // 将数据放入输入缓冲区
        _in_buffer.WriteAndPush(buffer, ret);

        // 2.调用message_callback进行业务处理
        if (_in_buffer.ReadAbleSize() > 0)
        {
            // shared_from_this从当前对象自身获取自身的shared_ptr管理对象
            // 需要当前类继承enable_shared_from_this<T>
            return _message_callback(shared_from_this(), &_in_buffer);
        }
    }

    // 描述符可写事件触发后的回调函数,将发送缓冲区中的数据进行发送
    void HandleWrite()
    {
        // _out_buffer中保存的数据就是要发送的数据
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
        if (ret < 0)
        {
            // 发送错误就该关闭连接了
            if (_in_buffer.ReadAbleSize() > 0)
            {
                _message_callback(shared_from_this(), &_in_buffer);
            }
            // 这时是实际关闭连接进行释放
            return Release();
        }

        // 将读偏移向后移动
        _out_buffer.MoveReadOffset(ret);

        // 如果当前是连接关闭状态,则有数据,发送完数据释放连接,没有数据则直接释放连接
        if (_out_buffer.ReadAbleSize() == 0)
        {
            // 没有数据发送了,关闭写事件监控
            _channel.DisableWrite();
            if (_statu == DISCONNECTING)
                return Release();
        }
        return;
    }

    // 描述符挂断事件触发后的回调函数
    void HandleClose()
    {
        // 一旦连接挂断了，套接字就什么都干不了了，因此有数据待处理就处理一下，完毕关闭连接
        if (_in_buffer.ReadAbleSize() > 0)
        {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        return Release();
    }

    // 描述符错误事件触发后的回调函数
    void HandleError()
    {
        return HandleClose();
    }

    // 描述符任意事件触发后的回调函数
    void HandleEvent()
    {
        if (_enable_inactive_release == true)
        {
            _loop->TimerRefresh(_conn_id);
        }
        if (_event_callback)
        {
            _event_callback(shared_from_this());
        }
    }

    // 连接获取之后,所处的状态下要进行的各种设置(给Channel设置事件回调,启动读监控)
    void EstableishdInLoop()
    {
        // 1.修改连接状态 2.启动读事件监控  3.调用回调函数
        // 当前状态必须一定是上层的半连接状态
        assert(_statu == CONNECTING);
        // 当前函数执行完毕则连接进入已完成连接状态
        _statu = CONNECTED;
        // 一旦启动读事件监控就可能会立即触发读事件,如果这时候启动了非活跃连接销毁
        _channel.EnableRead();

        if (_connected_callback)
            _connected_callback(shared_from_this());
    }

    // 这个接口是实际的释放接口
    void ReleaseInLoop()
    {
        // 1.修改连接状态,将其设置为DISCONNECTED
        _statu = DISCONNECTED;
        // 2.移除连接的事件监控
        _channel.Remove();
        // 3.关闭描述符
        _socket.Close();
        // 4.如果当前定时器队列中还有定时销毁任务,则取消任务
        if (_loop->HasTimer(_conn_id))
            CancelInactiveReleaseInLoop();
        // 5.调用关闭回调函数,避免先移除服务器管理的连接信息导致Connection被释放,再去处理会出错，因此先调用用户的回调函数
        if (_closed_callback)
            _closed_callback(shared_from_this());
        // 6.移除服务器内部管理的连接信息
        if (_server_closed_callback)
            _server_closed_callback(shared_from_this());
    }

    // 这个接口不是真正的发送接口,而只是把数据放到了发送缓冲区,启动了可写事件监控
    void SendInLoop(Buffer &buffer)
    {
        if (_statu == DISCONNECTED)
            return;
        _out_buffer.WriteBufferAndPush(buffer);
        if (_channel.WriteAble() == false)
        {
            _channel.EnableWrite();
        }
    }

    // 这个关闭操作并不是实际的连接关闭释放操作,需要判断还有没有数据待处理,待发送
    void ShutDownInLoop()
    {
        // 将连接设置为半连接状态
        _statu == DISCONNECTING;
        if (_in_buffer.ReadAbleSize() > 0)
        {
            if (_message_callback)
                _message_callback(shared_from_this(), &_in_buffer);
        }

        // 要么就是写入数据的时候出错关闭,要么就是没有待发送数据,直接关闭
        if (_out_buffer.ReadAbleSize() > 0)
        {
            if (_channel.WriteAble() == false)
            {
                _channel.EnableWrite();
            }
        }

        if (_out_buffer.ReadAbleSize() == 0)
        {
            Release();
        }
    }

    // 启动非活跃连接超时的释放规则
    void EnableInactiveReleaseInLoop(int sec)
    {
        // 1.将判断标志 _enable_inactive_release 置为true
        _enable_inactive_release = true;
        // 2.如果当前定时器销毁任务已经存在,那就刷新延迟一下时间
        if (_loop->HasTimer(_conn_id))
        {
            return _loop->TimerRefresh(sec);
        }
        // 3.如果不存在定时销毁任务,则新增
        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
    }

    void CancelInactiveReleaseInLoop()
    {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_conn_id))
        {
            _loop->TimerCancel(_conn_id);
        }
    }

    void UpgrateInLoop(const Any &context,
                       const ConnectedCallback &conn,
                       const MessageCallback &msg,
                       const ClosedCallback &closed,
                       const AnyEventCallback &event)
    {
        _context = context;
        _connected_callback = conn;
        _message_callback = msg;
        _closed_callback = closed;
        _event_callback = event;
    }

public:
    Connection(EventLoop *loop, const uint64_t &conn_id, int sockfd)
        : _conn_id(conn_id), _sockfd(sockfd), _enable_inactive_release(false), _loop(loop),
          _statu(CONNECTING), _socket(sockfd), _channel(loop, _sockfd)
    {
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
    }

    ~Connection()
    {
        LogMessage(NORMAL, "~Connection: release connection: %p", this);
    }

    // 获取管理的文件描述符
    int Fd() { return _sockfd; }
    // 获取连接ID
    int Id() { return _conn_id; }
    // 是否处于CONNECTED状态
    bool Connected() { return _statu == CONNECTED; }
    // 设置上下文
    void SetContext(const Any &context) { _context = context; }
    // 获取上下文,返回的是指针
    Any *GetContext() { return &_context; }

    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventedCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    void SetSrvClosedCallback(const ClosedCallback &cb) { _server_closed_callback = cb; }

    // 连接建立就绪后,进行channel回调设置,启动读监控,调用_connected_callback
    void Established()
    {
        return _loop->RunInLoop(std::bind(&Connection::EstableishdInLoop, this));
    }

    // 发送数据,将数据放到发送缓冲区,启动写事件监控
    void Send(const char *data, size_t len)
    {
        // 外界传入的data,可能是个临时的空间,我们现在只是把发送操作压入了任务池
        // 有可能并没有被立即执行
        // 因此有可能执行的时候，data指向的空间有可能已经被释放了。
        Buffer buffer;
        buffer.WriteAndPush(data, len);
        return _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buffer)));
    }

    // 提供给组件使用者的关闭接口 --并不实际关闭,需要判断有没有数据待处理
    void Shutdown()
    {
        return _loop->RunInLoop(std::bind(&Connection::ShutDownInLoop, this));
    }

    void Release()
    {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }

    // 启动非活跃销毁,并定义多长时间无通信就是非活跃,添加定时任务
    void EnableInactiveRelease(int sec)
    {
        return _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }

    // 取消非活跃销毁
    void CancleInactiveRelease()
    {
        return _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }

    // 切换协议--重置上下文以及阶段性处理函数
    void Update(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
                const ClosedCallback &closed, const AnyEventCallback &event)
    {
        _loop->AssertInLoop();
        _loop->RunInLoop(std::bind(&Connection::UpgrateInLoop, this, context, conn, msg, closed, event));
    }
};

class Acceptor
{
private:
    Socket _socket;   // 同于创建监听套接字
    EventLoop *_loop; // 对于监听套接字进行事件监控
    Channel _channel; // 对于监控套接字进行事件管理

    using AcceptCallback = std::function<void(int)>;
    AcceptCallback _accept_callback;

private:
    int CreateServer(const uint16_t &port)
    {
        bool ret = _socket.CreateServer(port);
        assert(ret == true);
        return _socket.Fd();
    }

    // 监听套接字的读事件回调处理函数,获取新连接,调用_accept_callback函数进行新连接处理
    void HandleRead()
    {
        int newfd = _socket.Accept();
        if (newfd < 0)
        {
            LogMessage(FATAL, "accept new fd failed");
            return;
        }
        if (_accept_callback)
            _accept_callback(newfd);
    }

public:
    /*不能将启动读事件监控，放到构造函数中，必须在设置回调函数后，再去启动*/
    /*否则有可能造成启动监控后，立即有事件，处理的时候，回调函数还没设置：新连接得不到处理，且资源泄漏*/
    Acceptor(EventLoop *loop, const uint16_t &port)
        : _socket(CreateServer(port)), _loop(loop),
          _channel(_loop, _socket.Fd())
    {
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
    }
    void SetAcceptCallback(const AcceptCallback &cb)
    {
        _accept_callback = cb;
    }
    void Listen()
    {
        _channel.EnableRead();
    }
};

class TcpServer
{
private:
    uint64_t _next_id; // 这是一个自动增长的连接ID
    uint16_t _port;
    int _timeout;                                       // 这是非活跃连接的统计时间---多长时间无通信就是非活跃连接
    bool _enable_inactive_release;                      // 是否启动了非活跃连接超时销毁的判断标志
    EventLoop _baseloop;                                // 这是主线程的EventLoop对象，负责监听事件的处理
    Acceptor _acceptor;                                 // 这是监听套接字的管理对象
    LoopThreadPool _pool;                               // 这是从属EventLoop线程池
    std::unordered_map<uint64_t, PtrConnection> _conns; // 保存管理所有连接对应的shared_ptr对象

    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    using Functor = std::function<void()>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;

private:
    // 添加定时任务
    void RunAfterInLoop(const Functor &task, int delay)
    {
        _next_id++;
        _baseloop.TimerAdd(_next_id, delay, task);
    }

    // 为新连接构造一个Connection进行管理
    void NewConnection(int fd)
    {
        _next_id++;
        PtrConnection conn(new Connection(_pool.GetNextLoop(), _next_id, fd));

        conn->SetConnectedCallback(_connected_callback);
        conn->SetClosedCallback(_closed_callback);
        conn->SetMessageCallback(_message_callback);
        conn->SetAnyEventedCallback(_event_callback);

        conn->SetSrvClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));

        // 启动非活跃连接释放
        if (_enable_inactive_release)
            conn->EnableInactiveRelease(_timeout);

        // 就绪初始化
        conn->Established();
        _conns.insert(std::make_pair(_next_id, conn));
    }

    void RemoveConnectionInLoop(const PtrConnection &conn)
    {
        int id = conn->Id();
        auto it = _conns.find(id);
        if (it != _conns.end())
        {
            _conns.erase(id);
        }
    }
    // 从管理Connection的_conns中移除连接信息
    void RemoveConnection(const PtrConnection &conn)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }

public:
    TcpServer(const uint16_t &port)
        : _next_id(0),
          _port(port),
          _enable_inactive_release(false),
          _acceptor(&_baseloop, port),
          _pool(&_baseloop)
    {
        // 设置监听套接字读事件的回调函数
        _acceptor.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        // 将监听套接字挂到baseloop上
        _acceptor.Listen();
    }

    // 设置线程数量
    void SetThreadCount(int count) { _pool.SetThreadCount(count); }

    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }

    // 启动非活跃连接销毁
    void EnableInactiveRelease(int timeout)
    {
        _enable_inactive_release = true;
        _timeout = timeout;
    }

    // 用于添加一个定时任务
    void RunAfter(const Functor &task, int delay)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }

    // 启动服务器
    void Start()
    {
        // 线程池的创建
        _pool.Create();
        // 事件监控--》就绪事件处理--》执行任务
        _baseloop.Start();
    }
};

// 移除监控
void Channel::Remove() { return _loop->RemoveEvent(this); }
// 添加监控
void Channel::Update() { return _loop->UpdateEvent(this); }

// 添加定时任务
void TimerWheel::TimerAdd(const uint64_t &id, const uint32_t &delay, const TaskFunc &cb)
{
    return _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}

// 刷新/延迟定时时间
void TimerWheel::TimerRefresh(const uint64_t &id)
{
    return _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}

// 取消定时任务
void TimerWheel::TimerCancel(const uint64_t &id)
{
    return _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}

// 当连接断开的时候继续发送数据会触发SIGPIPE异常,我们这里忽略这个信号
class NetWork
{
public:
    NetWork()
    {
        LogMessage(NORMAL, "SIGPIPE INIT");
        signal(SIGPIPE, SIG_IGN);
    }
};

static NetWork nw;

#endif